Modeliesation-E.P.S.A

De Permentier Thibault, Fabre Lucas, Goudezeune Antonin, Triglia Yanis

L’objectif de ce projet est d’approfondir un ou plusieurs domaines d’applications en donnant des éléments de formalisation, de connaissances et d’usages spécifiques à ce ou ces domaines, en particulier dans le domaine des mathématiques et de l’algorithmique.

Dans notre cas nous avons travailler sur " L'evolution d'une population d'age structuré " ce qui va nous permettre d' approfondir et de rendre plus concret certaine compétence comme :

1. Gestion des matrice
2. Valeur et vecteur propre
3. Evolution et analyse

Déroulé du projet

Tout d'abord nous avons commencer part étudier et assimiler le probleme en posant le probleme sur papier

Ensuite nous avons modélisé se probleme en utilisant le langage pyhon pour le rendre plus concret

BrainStorming

Nous avons commencé en essayant de comprendre exactement ce qu'impliquer cette notion d'évolution d'une population structurée en âge.

La première étape a été de comprendre que l'évolution de la population est simulée par la multiplication de la matrice qui représente les évolutions possibles de la population étudiée et le vecteur qui représente la population structurée par tranche d'âge.

Nous avons donc essayé de récupérer une matrice à partir du graphe présent dans la présentation du sujet.

modéle académique :

$$ matrice = \begin{bmatrix} 0.6 & 0.35 & 0.5 & 1\\ 0.4 & 0 & 0 & 0\\ 0 & 0.65 & 0 & 0\\ 0 & 0 & 0.5 & 0 \end{bmatrix}$$

La matrice est une matrice carrée dont la somme des colonnes est égale à 1.

Puis nous avons essayé de faire le calcul de multiplication de la matrice avec un vecteur test.

$$ vecteur = \begin{pmatrix} 10 \\ 0 \\ 0 \\ 0 \end{pmatrix} $$

Après nous avons fait plusieurs étapes de multiplication entre la matrice et le veteur pour avoir une idée des résultat que nous devrions obtenir avec notre code.

$$ \textrm{vecteur } t_1 = \begin{pmatrix} 6 \\ 4 \\ 0 \\ 0 \end{pmatrix} \textrm{vecteur } t_2 = \begin{pmatrix} 5 \\ 2.404 \\ 2.6 \\ 0 \end{pmatrix} \textrm{vecteur } t_3 = \begin{pmatrix} 5.14 \\ 2 \\ 1.5603 \\ 1.3 \end{pmatrix} \textrm{vecteur } t_4 = \begin{pmatrix} 5.864 \\ 2.056 \\ 1.3 \\ 0.7801 \end{pmatrix} \textrm{vecteur } t_5 = \begin{pmatrix} 5.668 \\ 2.3456 \\ 1.3364 \\ 0.65 \end{pmatrix} $$

Code multiplication matrice * vecteur python

Puis nous avons commencé notre implémentation du problème avec la création de fonction qui permet d'effectuer les actions importantes du problème. Ici la multiplication d'une matrice et d'un vecteur sans utiliser de bibliothèque supplémentaire.

Ce morceau de code permet de multiplier une matrice et un vecteur tant que leur nombre de ligne est le même. Puis la fonction retourne un vecteur de même taille que celui d'entrée qui contient le résultat de la multiplication.

def multiplyMatrixVector(myMatrix, myVector):
    resultVector = [0]*len(myVector)
    for i in range(len(myMatrix)):
        result = 0
        for j in range(len(myMatrix[i])):
            result += myMatrix[i][j] * myVector[j]
        resultVector[i] = result
    return resultVector

Code multiplication matrice * vecteur python version numpy :

Nous avons aussi créé une alternative au code ci-dessus en utilisant la bibliothèque numpy. Cela permet de s'assurer que l'autre forme ne contenais pas d'erreur.

le fait de faire le projet avec à chaque fois deux implémentations différentes est un choix fait par l'équipe, car la version du code fait sans bibliothéque est fait pour montré que nous avions compris quel était les enjeux du probléme qu'il fallait implémenté en code et la version du code avec numpy est la comme garde fous pour vérifier nos résultats car celle ci permet de trés simplement résoudre les problémes de calcule mais le fait sans notre compréhension.

Le code ci-dessous permet de la multiplication d'une matrice et d'un vecteur, mais aussi de l'affichage des résultats. Ce qui est le premier code qui nous permet de montrer l'évolution d'une population structurée en âge calculé par nous.

import numpy as np
import matplotlib.pyplot as plt

#%%
matrice = np.array([[0.6,0.35,0.5,1],[0.4,0,0,0],[0,0.65,0,0],[0,0,0.5,0]])

vector = np.array([10,0,0,0])

def MultiplyMV(Mat,Vec):
    
    t = Mat
    v = Vec
    
    a0 = [v[0]]
    a1= [v[1]]
    a2= [v[2]]
    a3 =[v[3]]
    
    for i in range(5):
        
        vect = np.dot(t,v)
        print(vect)
        v = vect
        y = 10
        a0.append(v[0])
        a1.append(v[1])
        a2.append(v[2])
        a3.append(v[3])
        
    
    plt.plot(a0,'red')
    plt.plot(a1,'green')
    plt.plot(a2,'blue')
    plt.plot(a3,'yellow')
    
    
    plt.plot(y)
    plt.show()      
        
   

print(MultiplyMV(matrice,vector))

[6. 4. 0. 0.]
[5.  2.4 2.6 0. ]
[5.14 2.   1.56 1.3 ]
[5.864 2.056 1.3   0.78 ]
[5.668  2.3456 1.3364 0.65  ]

None

Code somme de vecteur

Cette fonction, prend en paramètre un vecteur et retourne la somme de toutes les valeurs qu'il contient. Cette fonction nous permet de vérifier la somme des lignes, colonnes et des diagonales d'une matrice, pour observer comment se comporte la population quand les lignes, colonnes ou diagonales de la matrice changent.

def sumVector(myVector):
    result = 0
    for i in range(len(myVector)):
        result += myVector[i]
    return result

factorisation :

Cette deuxiéme version du code, montre de façon plus clair l'évolution d'une population structuré, ici la population de putois à pieds noirs d'Amérique du Nord récupéré de la présentation du projet, mais aussi de montré que le code peut désormait fonctionné avec n'importe quelle matrice et n'importe quel vecteur en entrée tant que la matrice et le vecteur on le même nombre de ligne.

import matplotlib.pyplot as plt
from matplotlib import rc

myMatrix = [[0.73, 1.25, 1.25, 1.25, 0],
             [0.39, 0, 0, 0, 0],
             [0, 0.67, 0, 0, 0],
             [0, 0, 0.67, 0, 0],
             [0, 0, 0, 0.64, 0]]

v1 = [10, 0, 0, 0, 0]

aVector = []
for i in range (5):
    aVector.append([v1[i]])
x = [0]
count = [sumVector(v1)]
for i in range(15):
    v2 = multiplyMatrixVector(myMatrix, v1)

    for j in range (5):
        aVector[j].append(v2[j])
    
    x.append(i+1)
    count.append(sumVector(v2))
    v1 = v2

for i in range(5):
    plt.plot(x, aVector[i], label="a"+str(i))

plt.plot(x, count, label="somme des populations")
leg = plt.legend(loc='upper center')
plt.show()

Animation :

Pour permettre une meilleure présentation qui serait plus claire et qui permettrai de mettre en valeur la notion d'évolution a chaque temps T d'une population structuré en âge, nous avons mis en place des animations. Le code présent ci-dessous est un code qui devrait fonctionner avec n'importe quelle matrice et n'importe quel vecteur tant que ceux-ci ont le même nombre de ligne. La population présente dans l'animation est une population prise au hasard tandis que la matrice est une matrice généré aléatoirement par du code que nous avons conçus. La matrice générée a la somme de ses colonnes égale à 1.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from IPython.display import HTML
import gen_matrice as k


vecteur = None
titre = None

def choix_vecteur(choix):
    global vecteur
    global titre
    if choix == 1 :
        #vecteur_jeune_population putois
        vecteur = np.array([320,225,142,90,60])
        titre = "évolution de la population des putois à pieds noir d'amérique du nord avec avantage au plus jeune"
        return vecteur , titre
    if choix == 2 :
        #vecteur_vieille_population putois
        vecteur = np.array([60,90,142,225,320])
        titre = "évolution de la population des putois à pieds noir d'amérique du nord avec avantage au plus vieux"
        return vecteur , titre
    if choix == 3 :
        #vecteur de test géneral
        vecteur = np.array([5,3,3,2,4])
        titre = "évolution d'une population modéle génératif"
        return vecteur ,titre

a = 10
b = 10

def graph_with_animation(matrice,vecteur,a,b):
        global titre
        
        a = a
        b = b
        mat = np.array(matrice)
        
        if len(vecteur) == len(mat) : 

    
            #on défini notre graphe ou chaque ligne correspond à un vecteur pour l'instant vide
            fig, ax = plt.subplots()
            ligne = []
            for i in range (0,len(mat)):
                ligne.append(ax.plot([], [], '-', label=f'a{i}')[0])
                
            
            def init():
                #on limite notre graphe
                ax.set_xlim(0, a)
                ax.set_ylim(0, b)
                ax.legend() 
                return ligne

            def update(frame):
            
                global vecteur
                #On va multiplier la matrice par le cecteur tant que update et appeler
                vect = np.dot(mat, vecteur)
                vecteur = vect
            
                print("le vecteur correspond à : " ,np.round(vect, 0), "le somme du vecteur correspond à : " ,np.sum(vect))
                
                for k in range (0,len(vect)):
                    index_vector[k].append(vect[k])
                    
                #on met a jour els ligne qui coresspondent respectivement a a0,a1,a2,a3
                for i in range (0,len(mat)):
                    ligne[i].set_data(range(frame + 2), index_vector[i][:frame + 2])

                return ligne

            #on donne le point de départ de nos vecteur
            index_vector = []
            for j in range (0,len(vecteur)):
                index_vector.append([vecteur[j]])


            #on lance l'animation en appelant update 20 fois
            ani = FuncAnimation(fig, update, frames=20, init_func=init, blit=True)
            

            plt.title(titre)
            return HTML(ani.to_jshtml())
        else:
            print("la matrice ne fait pas la meme taille que le vecteur")
            return 
#on utilise ici le vecteur de test        
choix_vecteur(3)
#on lance l'animation
graph_with_animation(k.genMatricColEqual(5,1),vecteur,10,10)

le vecteur correspond à :  [11.  3.  1.  1.  0.] le somme du vecteur correspond à :  17.0
le vecteur correspond à :  [12.  2.  2.  1.  1.] le somme du vecteur correspond à :  16.999999999999996
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.999999999999993
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.999999999999996
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.999999999999996
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.999999999999993
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.999999999999996
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.999999999999993
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.999999999999993
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.99999999999999
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.99999999999999
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.99999999999999
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.99999999999999
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.99999999999999
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.999999999999993
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.99999999999999
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.999999999999993
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.99999999999999
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.99999999999999
le vecteur correspond à :  [12.  2.  2.  0.  1.] le somme du vecteur correspond à :  16.99999999999999

Once Loop Reflect

Pour générer les matrices de test nous utilisons différentes fonctions :

Tout d’abord nous avons genMatricLineEqual(n,x) qui nous génère un matrice n² dont la somme de chaque ligne est égale à x, cette fonction fait aussi que la somme de la colonne 1 est plus grande que la somme de la colonne 2 et ainsi de suite.

import random as rd
def genMatricLineEqual(n,x):
    mat = []
    for i in range(n):
        ligne = []
        borne_sup=float(x)
        diff = 0.0
        for j in range(n):
            if j == n-1 :
                ligne.append(round(float(x)-diff,2))
            else :
                tmp = round(rd.uniform(0.0, borne_sup),2)
                ligne.append(tmp)
                borne_sup -= tmp 
                diff += tmp
        mat.append(ligne)

    return mat

print(genMatricLineEqual(5,1))

[[0.42, 0.03, 0.22, 0.04, 0.29], [0.37, 0.48, 0.01, 0.03, 0.11], [0.71, 0.09, 0.12, 0.06, 0.02], [0.88, 0.02, 0.1, -0.0, 0.0], [0.5, 0.49, 0.0, 0.01, 0.0]]

Nous utilisons également genMatricColEqual(n,x) qui nous génère un matrice n² dont la somme de chaque colonne est égale à x, cette fonction fait aussi que la somme de la ligne 1 est plus grande que la somme de la ligne 2 et ainsi de suite.

def genMatricColEqual(n,x):
    mat =[]
    diff = [0]*n
    borne_sup=[float(x)]*n

    for i in range(n):
        ligne = []
        for j in range(n):
            if i == n-1 :
                ligne.append(round(float(x)-diff[j],2))
            else :
                tmp = round(rd.uniform(0.0, borne_sup[j]),2)
                ligne.append(tmp)
                borne_sup[j] -= tmp 
                diff[j] += tmp
        mat.append(ligne)

    return mat

print(genMatricColEqual(4,3))

[[0.53, 1.44, 2.04, 1.33], [2.18, 0.63, 0.76, 1.12], [0.04, 0.6, 0.2, 0.46], [0.25, 0.33, 0.0, 0.09]]

Et pour finir nous utilisons genMatricDiagEqual(n,x,reste) qui nous génère un matrice n² dont la somme de la diagonale principale est égale à x, pour les autres valeurs sont soit égale à 0 si la variable reste est égale à 0 et si la variable reste n’est pas égale à 0 les autres valeurs seront aléatoire.

def genMatricDiagEqual(n,x,reste):
    mat =[]
    diff = 0
    borne_sup=float(x)

    for i in range(n):
        ligne = []
        for j in range(n):
            if i == n-1 and j ==n-1 :
                ligne.append(round(float(x)-diff,2))
            elif i==j :
                tmp = round(rd.uniform(0.0, borne_sup),2)
                ligne.append(tmp)
                borne_sup -= tmp 
                diff += tmp
            elif reste == 0 :
                ligne.append(0.0)
            else :
                ligne.append(round(rd.uniform(0.0, float(x)),2))
        mat.append(ligne)

    return mat

print(genMatricDiagEqual(5, 1, 0))

[[0.22, 0.0, 0.0, 0.0, 0.0], [0.0, 0.14, 0.0, 0.0, 0.0], [0.0, 0.0, 0.25, 0.0, 0.0], [0.0, 0.0, 0.0, 0.39, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0]]

Analyse des résultats

Analyse 1 : Modèle Fictif (Test général)

Toutes les matrices utilisées pour ce test sont générées aléatoirement via diverses méthodes que l’on a réalisées et que vous avez pu voir précedement.

Test pour matrice Ligne :

Pour une valeur qui vaut 0.5 :

#on utilise le vecteur de test pour une valeur de ligne de 0.5
choix_vecteur(3)
graph_with_animation(k.genMatricLineEqual(5,0.5),vecteur,10,10)

le vecteur correspond à :  [2. 2. 2. 2. 2.] le somme du vecteur correspond à :  9.760000000000002
le vecteur correspond à :  [1. 1. 1. 1. 1.] le somme du vecteur correspond à :  4.561
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  2.3400000000000003
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  1.15933646
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.5816213966000001
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.29045439532000006
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.14529219345030003
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.07263423776413662
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.03631928250922342
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.01815924650630727
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.009079695274111477
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.004539834497000462
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.0022699196458728426
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.0011349593855413448
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.0005674797725723897
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.0002837398717265566
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  0.00014186993851965054
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  7.093496877517631e-05
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  3.5467484476011234e-05
le vecteur correspond à :  [0. 0. 0. 0. 0.] le somme du vecteur correspond à :  1.7733742221873034e-05

Once Loop Reflect

Pour une valeur qui vaut 1 :

#on utilise le vecteur de test pour une valeur de ligne de 1
choix_vecteur(3)
graph_with_animation(k.genMatricLineEqual(5,1),vecteur,4,8)

le vecteur correspond à :  [3. 4. 4. 4. 3.] le somme du vecteur correspond à :  18.16
le vecteur correspond à :  [4. 3. 3. 4. 4.] le somme du vecteur correspond à :  17.7813
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.867263
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.848535490000003
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.852510335100003
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.851650520379
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.85184470018187
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.851799061651537
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.851809986972157
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.851807379817252
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.85180799290418
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.851807851010214
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.85180788350576
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.851807876085374
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.85180787778556
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.851807877393608
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.851807877484454
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.851807877463344
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.851807877468246
le vecteur correspond à :  [4. 4. 4. 4. 4.] le somme du vecteur correspond à :  17.851807877467106

Once Loop Reflect

Pour une valeur supérieur à 1 :

#on utilise le vecteur de test pour une valeur de ligne de 0.5
choix_vecteur(3)
graph_with_animation(k.genMatricLineEqual(5,1.9),vecteur,50,30)

le vecteur correspond à :  [8. 7. 9. 9. 9.] le somme du vecteur correspond à :  41.0
le vecteur correspond à :  [15. 15. 14. 15. 15.] le somme du vecteur correspond à :  73.3215
le vecteur correspond à :  [28. 28. 29. 29. 29.] le somme du vecteur correspond à :  142.219647
le vecteur correspond à :  [54. 54. 54. 54. 54.] le somme du vecteur correspond à :  269.77093563
le vecteur correspond à :  [103. 102. 103. 103. 103.] le somme du vecteur correspond à :  513.2261660935001
le vecteur correspond à :  [195. 195. 195. 195. 195.] le somme du vecteur correspond à :  975.2474644267593
le vecteur correspond à :  [371. 371. 371. 371. 371.] le somme du vecteur correspond à :  1853.1895639594309
le vecteur correspond à :  [704. 704. 704. 704. 704.] le somme du vecteur correspond à :  3521.172821329169
le vecteur correspond à :  [1338. 1338. 1338. 1338. 1338.] le somme du vecteur correspond à :  6690.327917135694
le vecteur correspond à :  [2542. 2542. 2542. 2542. 2542.] le somme du vecteur correspond à :  12711.689814087662
le vecteur correspond à :  [4830. 4830. 4830. 4830. 4830.] le somme du vecteur correspond à :  24152.26167486141
le vecteur correspond à :  [9178. 9178. 9178. 9178. 9178.] le somme du vecteur correspond à :  45889.33376129538
le vecteur correspond à :  [17438. 17438. 17438. 17438. 17438.] le somme du vecteur correspond à :  87189.7611881033
le vecteur correspond à :  [33132. 33132. 33132. 33132. 33132.] le somme du vecteur correspond à :  165660.56595190044
le vecteur correspond à :  [62951. 62951. 62951. 62951. 62951.] le somme du vecteur correspond à :  314755.0897560149
le vecteur correspond à :  [119607. 119607. 119607. 119607. 119607.] le somme du vecteur correspond à :  598034.6810977793
le vecteur correspond à :  [227253. 227253. 227253. 227253. 227253.] le somme du vecteur correspond à :  1136265.9018193688
le vecteur correspond à :  [431781. 431781. 431781. 431781. 431781.] le somme du vecteur correspond à :  2158905.2191151395
le vecteur correspond à :  [820384. 820384. 820384. 820384. 820384.] le somme du vecteur correspond à :  4101919.92046036
le vecteur correspond à :  [1558730. 1558730. 1558730. 1558730. 1558730.] le somme du vecteur correspond à :  7793647.85190553

Once Loop Reflect

Déduction Analyse :

Avant de commencer cette analyse, il est bon de préciser que chaque courbe correspond à un stade d'âge de la population. Comme pour notre première analyse, nous utilisons un modèle généré, donc fictif, les données ne refléteront pas la réalité. Cela signifie que si ces données améne à une déduction qui sort de la logique c'est tout à fait normal, car ces chiffres ne sont que générés. Je rappelle également que le vecteur correspond au nombre de personnes dans la population selon l'âge. Et dernière chose, une itération correspond à un temps passé, mais non donné.

Donc, ce que l'on peut déduire de cette analyse pour :

• Le premier point(où la population démarre avec un coefficient d'évolution inférieur à 1) : Ce cas refléte le fait que la population à tous les stades d'âge ne se reproduit pas ou très peu. Donc ici nous aurons une décroissance à travers le temps de maniére constant de la population jusqu'au moment où elle touchera à son extinction.

• Le deuxième point (ou la population démarre un coefficient égal à 1): Ce cas refléte que la population se reproduit à chaque stade d'âge de manière moyenne. Ici nous aurons donc une somme de la population qui reste assez stable.

• Enfin, pour le dernier axe, lorsque la population démarre avec un coefficient supérieur à 1 (c'est-à-dire que le taux de reproduction à chaque stade d'âge de la population est élevé), on constate logiquement une augmentation de la population à chaque temps.

Analyse 2 : Modèle putois (Test réel)

Pour cette analyse, on va prendre un modèle qui existe déjà, qui est le Putois à pieds-noirs d'Amérique du Nord (fourni dans la présentation du projet). Cette analyse sera suivie de statistiques pour appuyer les propos donnés.

Pour les différents états, il y en a 5, ça va de a0 à a5. On prendra en compte que le numéro de l'état correspondra à l'âge du putois, sachant qu’un putois vit entre 4 et 5 ans (a0 = putois qui a entre 1 et 12 mois, a1 = putois qui a 1 an...). Donc, dans ce cas, on pourra avoir une analyse plus détaillée et complète que pour la première.

Pour le premier vecteur, partons du principe qu’on part d’une population plutôt jeune avec un peu de personnes dans un âge moyen et très peu dans le bel âge. Voici à quoi ressemble le vecteur.

$$ vecteur jeune = \begin{pmatrix} 320 \\ 225 \\ 142 \\ 90 \\ 60 \end{pmatrix} $$

matrice_putois = [[0.73, 1.25, 1.25, 1.25, 0],
             [0.39, 0, 0, 0, 0],
             [0, 0.67, 0, 0, 0],
             [0, 0, 0.67, 0, 0],
             [0, 0, 0, 0.64, 0]]

#On prend le vecteur de répartition des putois avec avantages à la population jeune
choix_vecteur(1)
graph_with_animation(matrice_putois,vecteur,50,400)

le vecteur correspond à :  [805. 125. 151.  95.  58.] le somme du vecteur correspond à :  1233.14
le vecteur correspond à :  [1051.  314.   84.  101.   61.] le somme du vecteur correspond à :  1610.3026
le vecteur correspond à :  [1390.  410.  210.   56.   65.] le somme du vecteur correspond à :  2131.1204850000004
le vecteur correspond à :  [1860.  542.  275.  141.   36.] le somme du vecteur correspond à :  2853.7214256
le vecteur correspond à :  [2555.  725.  363.  184.   90.] le somme du vecteur correspond à :  3917.9617800255
le vecteur correspond à :  [3456.  996.  486.  243.  118.] le somme du vecteur correspond à :  5299.775130917492
le vecteur correspond à :  [4680. 1348.  668.  326.  156.] le somme du vecteur correspond à :  7177.310717005593
le vecteur correspond à :  [6343. 1825.  903.  447.  208.] le somme du vecteur correspond à :  9727.28629576371
le vecteur correspond à :  [8600. 2474. 1223.  605.  286.] le somme du vecteur correspond à :  13188.298881072214
le vecteur correspond à :  [11655.  3354.  1657.   819.   387.] le somme du vecteur correspond à :  17873.59553024055
le vecteur correspond à :  [15797.  4546.  2247.  1110.   524.] le somme du vecteur correspond à :  24224.869033623236
le vecteur correspond à :  [21411.  6161.  3046.  1506.   711.] le somme du vecteur correspond à :  32833.8675114245
le vecteur correspond à :  [29020.  8350.  4128.  2041.   964.] le somme du vecteur correspond à :  44502.420919056276
le vecteur correspond à :  [39333. 11318.  5595.  2766.  1306.] le somme du vecteur correspond à :  60317.160834681155
le vecteur correspond à :  [53311. 15340.  7583.  3748.  1770.] le somme du vecteur correspond à :  81752.15964150803
le vecteur correspond à :  [72256. 20791. 10278.  5081.  2399.] le somme du vecteur correspond à :  110804.61820176043
le vecteur correspond à :  [97934. 28180. 13930.  6886.  3252.] le somme du vecteur correspond à :  150181.49593604813
le vecteur correspond à :  [132737.  38194.  18881.   9333.   4407.] le somme du vecteur correspond à :  203551.77463019147
le vecteur correspond à :  [179908.  51767.  25590.  12650.   5973.] le somme du vecteur correspond à :  275888.3735947613
le vecteur correspond à :  [243842.  70164.  34684.  17145.   8096.] le somme du vecteur correspond à :  373931.3781080064

Once Loop Reflect

On voit donc, sur cette analyse d'évolution sur 20 ans (parce que nous faisons 20 itérations), que la population ne cesse d'augmenter dans l'état a0, mais que pour les autres états, il va y avoir une baisse jusqu'à un certain point, pour ensuite évoluer de manière croissante et exponentielle.

Pour le deuxième vecteur, on va effectuer la même chose que pour le premier, mais en inversant, c’est-à-dire qu'il y aura plus de personnes d'âge avancé que de jeunes.

$$ vecteurvieux = \begin{pmatrix} 60 \\ 90 \\ 142 \\ 225 \\ 320 \end{pmatrix} $$

#On prend le vecteur de répartition des putois avec avantages à la population vieille
choix_vecteur(2)
graph_with_animation(matrice_putois,vecteur,50,400)

le vecteur correspond à :  [615.  23.  60.  95. 144.] le somme du vecteur correspond à :  937.8899999999999
le vecteur correspond à :  [673. 240.  16.  40.  61.] le somme du vecteur correspond à :  1029.3745999999999
le vecteur correspond à :  [861. 262. 161.  11.  26.] le somme du vecteur correspond à :  1320.2499699999998
le vecteur correspond à :  [1170.  336.  176.  108.    7.] le somme du vecteur correspond à :  1796.2102498
le vecteur correspond à :  [1628.  456.  225.  118.   69.] le somme du vecteur correspond à :  2496.3214966915
le vecteur correspond à :  [2188.  635.  306.  151.   75.] le somme du vecteur correspond à :  3354.4608865592945
le vecteur correspond à :  [2961.  853.  425.  205.   96.] le somme du vecteur correspond à :  4541.322202788653
le vecteur correspond à :  [4016. 1155.  572.  285.  131.] le somme du vecteur correspond à :  6158.906304893654
le vecteur correspond à :  [5446. 1566.  774.  383.  182.] le somme du vecteur correspond à :  8351.838839438362
le vecteur correspond à :  [7380. 2124. 1049.  518.  245.] le somme du vecteur correspond à :  11316.704568250034
le vecteur correspond à :  [10002.  2878.  1423.   703.   332.] le somme du vecteur correspond à :  15338.18581509013
le vecteur correspond à :  [13557.  3901.  1928.   953.   450.] le somme du vecteur correspond à :  20789.495840099287
le vecteur correspond à :  [18375.  5287.  2614.  1292.   610.] le somme du vecteur correspond à :  28177.722149557725
le vecteur correspond à :  [24904.  7166.  3542.  1751.   827.] le somme du vecteur correspond à :  38190.98481491449
le vecteur correspond à :  [33755.  9713.  4801.  2373.  1121.] le somme du vecteur correspond à :  51763.01695261145
le vecteur correspond à :  [45750. 13164.  6508.  3217.  1519.] le somme du vecteur correspond à :  70158.203252554
le vecteur correspond à :  [62009. 17843.  8820.  4360.  2059.] le somme du vecteur correspond à :  95090.46704699047
le vecteur correspond à :  [84045. 24183. 11955.  5909.  2790.] le somme du vecteur correspond à :  128882.92782023468
le vecteur correspond à :  [113912.  32778.  16203.   8010.   3782.] le somme du vecteur correspond à :  174684.31705768293
le vecteur correspond à :  [154393.  44426.  21961.  10856.   5126.] le somme du vecteur correspond à :  236762.23606573103

Once Loop Reflect

Grâce à ces données inversées, on voit donc que le nombre de personnes par âge se rapproche de celui du premier vecteur, c’est-à-dire que la population plus jeune reprend le dessus sur la plus vieille. Cependant, si l'on suit l'évolution du vecteur ou du graphique, on voit que pour tous les états, sauf encore pour a0, il y a une grande chute à partir de la population de départ, jusqu’à un point donnée, pour ensuite réévoluer de manière croissante (à noter que ce pic négatif est plus important que celui où la population jeune était supérieure).

Quelque Statistique

Diagramme camembert de la répartition de la population avant et aprés itération

vecteur_jeune_population_non_modifiée = np.array([320,225,142,90,60])
vecteur_vieille_population_non_modifiée = np.array([60,90,142,225,320])

def graphique_camembert(vecteur,etat):
   
    labels =[]
    for i in range (0,len(vecteur)):
        labels.append(f'a{i}')

    colors = ['yellowgreen', 'gold', 'red','lightskyblue', 'lightcoral']

    plt.pie(vecteur, labels=labels, colors=colors, 
            autopct='%1.1f%%', shadow=True, startangle=90)

    plt.axis('equal')

    if etat == 0 :
        plt.title("Graphique proportion en pourcentage de l'évolution des putoits (avec avantage jeune) aprés 0 itération dans le temps")
    elif etat == 1 :
        plt.title("Graphique proportion en pourcentage de l'évolution des putoits (avec avantage vieux) aprés 0 itération dans le temps")
    elif etat == 2 :
        plt.title("Graphique proportion en pourcentage de l'évolution des putoits (avec avantage jeune) aprés 20 itération dans le temps")
    elif etat == 3 :
        plt.title("Graphique proportion en pourcentage de l'évolution des putoits (avec avantage vieux) aprés 20 itération dans le temps")

        
    plt.show()

graphique_camembert(vecteur_jeune_population_non_modifiée ,0)

choix_vecteur(1)
v = vecteur
for i in range(0,20):
  v = multiplyMatrixVector(matrice_putois,v)
print(v)
graphique_camembert(v ,2)

graphique_camembert(vecteur_vieille_population_non_modifiée ,1)

choix_vecteur(2)
v = vecteur
for i in range(0,20):
  v = multiplyMatrixVector(matrice_putois,v)
print(v)
graphique_camembert(v ,3)

[243841.89988776657, 70164.01443414594, 34684.123681580924, 17145.37794823162, 8095.962156281268]

[154393.44450225774, 44425.768213152114, 21960.955200514225, 10855.94462518514, 5126.123524621926]

Diagramme en bars de la répartition de la population

def graphique_bar(vecteur,vecteur2):
    
    # On crée notr graphique de barre
    fig, ax = plt.subplots()
    bar_width = 0.25
    abscisse = ["a0", "a1", "a2", "a3","a4"]
    ax.bar(np.arange(len(abscisse)), vecteur, width=bar_width, label="itération 0",color = "grey")
    ax.bar(np.arange(len(abscisse)) + bar_width, vecteur2, width=bar_width, label="itération max",color = "red")

    # Configuration des axes
    ax.set_xticks(np.arange(len(abscisse)) + bar_width)
    ax.set_xticklabels(abscisse)
    ax.set_xlabel("Stade d'Age")
    ax.set_ylabel("Nombre de personne")
    ax.set_title("Graphique de différence entre le nombre de personne par age")
    ax.legend()

    # on affiche le graphique
    plt.show()
    
choix_vecteur(1)
v = vecteur
for i in range(0,1):
  v = multiplyMatrixVector(matrice_putois,v)
graphique_bar(vecteur_jeune_population_non_modifiée,v)
for i in range(0,7):
  v = multiplyMatrixVector(matrice_putois,v)
graphique_bar(vecteur_jeune_population_non_modifiée,v)
for i in range(0,15):
  v = multiplyMatrixVector(matrice_putois,v)
graphique_bar(vecteur_jeune_population_non_modifiée,v)


choix_vecteur(2)
v = vecteur
for i in range(0,1):
  v = multiplyMatrixVector(matrice_putois,v)
graphique_bar(vecteur_vieille_population_non_modifiée,v)
for i in range(0,7):
  v = multiplyMatrixVector(matrice_putois,v)
graphique_bar(vecteur_vieille_population_non_modifiée,v)
for i in range(0,15):
  v = multiplyMatrixVector(matrice_putois,v)
graphique_bar(vecteur_vieille_population_non_modifiée,v)

Calcul Statistique

def calcul_statistique_jeune():
    print("Moyenne avec population jeune supérieur etat 0: ",np.mean(vecteur_jeune_population_non_modifiée)) 
    print("Ecart-type avec population jeune supérieur etat 0: ",np.std(vecteur_jeune_population_non_modifiée))
    print("Médiane avec population jeune supérieur etat 0: ", np.median(vecteur_jeune_population_non_modifiée))
    
def calcul_statistique_vieille():
    print("Moyenne avec population vieille supérieur etat 0: ",np.mean(vecteur_vieille_population_non_modifiée)) 
    print("Ecart-type avec population vieille supérieur etat 0: ",np.std(vecteur_vieille_population_non_modifiée))
    print("Médiane avec population vieille supérieur etat 0: ", np.median(vecteur_vieille_population_non_modifiée))

def calcul_statistique(vec,etat):
    titrem = None
    titrec = None
    tritemed = None
    
    if etat == 0:
        titrem = "Moyenne avec population jeune supérieur etat 20:"
        titrec = "Ecart-type avec population jeune supérieur etat 20:"
        tritemed = "Médiane avec population jeune supérieur etat 20:"
    elif etat == 1 :
        titrem = "Moyenne avec population vieille supérieur etat 20:"
        titrec = "Ecart-type avec population vieille supérieur etat 20:"
        tritemed = "Médiane avec population vieille supérieur etat 20:"
        
    
    print(titrem,np.mean(vec)) 
    print(titrec,np.std(vec))
    print(tritemed, np.median(vec))
    
    
choix_vecteur(1)
v = vecteur
for i in range(0,1):
    v = multiplyMatrixVector(matrice_putois,v)

calcul_statistique_jeune()
print()
calcul_statistique(v,0)
print()
print()


choix_vecteur(1)
v = vecteur
for i in range(0,1):
    v = multiplyMatrixVector(matrice_putois,v)

calcul_statistique_vieille()
print()
calcul_statistique(v,1)

Moyenne avec population jeune supérieur etat 0:  167.4
Ecart-type avec population jeune supérieur etat 0:  94.63107312083066
Médiane avec population jeune supérieur etat 0:  142.0

Moyenne avec population jeune supérieur etat 20: 246.62800000000001
Ecart-type avec population jeune supérieur etat 20: 280.8297180428026
Médiane avec population jeune supérieur etat 20: 124.80000000000001


Moyenne avec population vieille supérieur etat 0:  167.4
Ecart-type avec population vieille supérieur etat 0:  94.63107312083066
Médiane avec population vieille supérieur etat 0:  142.0

Moyenne avec population vieille supérieur etat 20: 246.62800000000001
Ecart-type avec population vieille supérieur etat 20: 280.8297180428026
Médiane avec population vieille supérieur etat 20: 124.80000000000001

Conclusion sur Analyse + Statistique

Pour conclure sur l'analyse des putois à pied noir d'amérique du nord on voit que dans tout les cas quelque soit le vecteur de départ par lequel on commence tant que les coefficcient matricille d'une ligne ou collone n'est pas inférieur à 1 la population contenue à l'age a0 sera toujours supérieur au file des itération (du temps) car enormement de putois a ce stade la produise de la population appartenant au stade a0 et c'est également le cas des autre état de a1 à a3 qui produise non pas pour leur état mais pour a0 (c'est normal, car les adultes ne produisent pas des adultes.). Ce type d'analyse est bien sur différents selon les espèces, celle-là se reproduisant très tôt à ses propres spécificités.

Ce que l'on peut en déduire d'un point de vue mathématiquement parlant c'est que l'évolution d'une population structurée en âge est juste le fait de plusieurs multiplications entre la matrice du modèle et le vecteur de population. Nous pouvons remarquer que la matrice tient une place capitale dans le modèle, car nous avons remarqué que quand les valeurs de la matrice sont assez élevé peu importe le vecteur de population de départ les tendances reste les mêmes. Ainsi, le modèle de l'évolution d'une population structurée en âge est un très bon modèle statistique pour avoir une tendance de la croissance d'une population (sans prendre en compte d'autre facteur que la reproduction de cette population).

Description de la répartition des taches de chacun, ainsi que la répartition des points

Pour ce projet, les différentes tâches à réaliser on était répartie de la manière suivante :

1. Thibault :

• Brainstorming sur papier de comment multiplier une matrice et un vecteur pour définir quelle direction doit prendre le code
• Réalisation d'une première version de code python permettant de multiplier une matrice et un vecteur
• Animation

2. Lucas :

• Réalisation d'une première version de code python permettant de multiplier une matrice et un vecteur
• Refactor du code en question
• Statistiques
• Code python permettant de générer différentes matrices

3. Antonin :

• Réalisation d'une première version de code python permettant de multiplier une matrice et un vecteur
• Documentation (prise de note des tâches réalisé)
• Réalisation du Jupyter Notebook
• Animation

4. Yanis :

• Brainstorming sur papier de comment multiplier une matrice et un vecteur pour définir quelle direction doit prendre le code
• Réalisation d'une première version de code python permettant de multiplier une matrice et un vecteur
• Animation
• Statistiques

Pour la répartition des points de contribution, nous avons selon nous tous participer de la même manière à ce projet de modélisation "L'évolution d'une population d'âge structuré. "

Donc la répartition est la suivante :

• Thibault : 25%
• Lucas : 25%
• Antonin : 25%
• Yanis : 25%